1、合并k个有序链表
思想：遍历k个链表，按照两个有序链表方式进行排列；
class Solution {
public:
    ListNode* _mergeKLists(ListNode* l,ListNode* r)
    {
        if(l==nullptr||r==nullptr)
            return l==nullptr?r:l;
        ListNode* head=nullptr;
        if(l->val>r->val)
        {
            head=r;
            r=r->next;
        }   
        else 
        {
            head=l;
            l=l->next;
        }
        ListNode* tail=head;
        ListNode* curA=l;
        ListNode* curB=r;
        while(curA&&curB)
        {
            if(curA->val>curB->val)
            {
                tail->next=curB;
                curB=curB->next;
                tail=tail->next;
            }
            else
            {
                tail->next=curA;
                curA=curA->next;
                tail=tail->next;
            }
        }
        if(curA)
            tail->next=curA;
        if(curB)
            tail->next=curB;
        return head;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode* ans=nullptr;
        for(int i=0;i<lists.size();i++)
        {
            ans=_mergeKLists(ans,lists[i]);
        }
        return ans;
    }
};

2、单词拆分
思想：动态规划，f(i)表示字符串的前i个字符在不在单词中。
class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        vector<bool> v(s.size()+1,false);
        v[0]=true;
        //表示s的前i个字符是否可以由字典表示，也就是判断i前面字符串是否在字典里
        for(int i=0;i<s.size();i++)
        {
            if(v[i]==false)
                continue;
            for(auto word:wordDict)
            {
                if((word.size()+i)<=s.size()&&s.substr(i,word.size())==word)
                    v[i+word.size()]=true;
            }
        }
        return v[s.size()];
    }
};